home *** CD-ROM | disk | FTP | other *** search
/ Network CD 2 / Network CD - Volume 2.iso / programs / internet / tcp / clients / atcp_ttcp10.lha / amiga / s_socket.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-10  |  10.5 KB  |  653 lines
  1. #ifndef NOIDENT
  2. const static char RCSid[] = "$Header: qc:c-src/common/misclib/RCS/s_socket.c,v 1.6 1993/10/03 17:48:42 alph Exp $";
  3. #endif
  4.  
  5. /*
  6.  *----------------------------------------------------------------------
  7.  *
  8.  * $Source: qc:c-src/common/misclib/RCS/s_socket.c,v $
  9.  * $Revision: 1.6 $
  10.  * $Date: 1993/10/03 17:48:42 $
  11.  * $State: Exp $
  12.  * $Author: alph $
  13.  * $Locker:  $
  14.  *
  15.  *----------------------------------------------------------------------
  16.  *
  17.  * alph 
  18.  * 
  19.  * This code is (C) Copyright 1993 by Carsten Heyl. All rights reserved.
  20.  * This code is NOT in the Public Domain.
  21.  * It may be copied, modified or distributed as long as this notice is
  22.  * present.
  23.  *
  24.  *----------------------------------------------------------------------
  25.  * $Log: s_socket.c,v $
  26.  * Revision 1.6  1993/10/03  17:48:42  alph
  27.  * *** empty log message ***
  28.  *
  29.  * Revision 1.6  1993/10/03  17:48:42  alph
  30.  * *** empty log message ***
  31.  *
  32.  * Revision 1.5  1993/10/03  16:36:54  alph
  33.  * corrected sendto parameter
  34.  *
  35.  * Revision 1.4  1993/10/02  19:34:00  alph
  36.  * added s_sendto
  37.  *
  38.  * Revision 1.3  1993/10/02  19:10:09  alph
  39.  * added header
  40.  *
  41.  *----------------------------------------------------------------------
  42.  */
  43.  
  44.  
  45. #include <stdio.h>
  46. #include <stdlib.h>
  47. #include <string.h>
  48. #include <fcntl.h>
  49.  
  50. #include <errno.h>
  51.  
  52. #include <sys/types.h>
  53. #include <netinet/in.h>
  54.  
  55. #ifdef __SASC
  56. #if 0
  57. #include <clib/socket_protos.h>
  58. #endif
  59. #include <pragmas/socket_pragmas.h>
  60. #include <proto/socket.h>
  61. #endif
  62.  
  63. #define PRIVATE_SOCKET_H
  64. #include "s_socket.h"
  65.  
  66. #define MAXFH S_MAXFH
  67.  
  68. /* FIXME: set atexit-handler for sockets too */
  69.  
  70. /* extern int SocketBase; */
  71.  
  72. static FILEEXT *files;
  73.  
  74. static void *zmalloc(size_t l)
  75. {
  76.     unsigned char *p = malloc(l);
  77.  
  78.     if(p)
  79.     memset(p, 0x00, l);
  80.  
  81.     return p;
  82. }
  83.  
  84. #define BUFSIZE 512
  85.  
  86. /*
  87.  does a FILE exists, which references fd ?
  88.  */
  89.  
  90. static int fd_has_refs(FILE *as, int fd)
  91. {
  92.     while(as)
  93.     {
  94.     if(fileno(as) == fd)
  95.         return 1;
  96.     as = as->_next;
  97.     }
  98.     return 0;
  99. }
  100.  
  101. static void s_fcloseall(void)
  102. {
  103.     while(files)
  104.     s_fclose(files);
  105. }
  106.  
  107. FILE *s_fdopen(int fd, const char *mode)
  108. {
  109.     FILEEXT *af;
  110.     unsigned char *buf;
  111.  
  112.     if(fd < MAXFH)
  113.     return fdopen(fd,mode);
  114.     else
  115.     {
  116.     af = zmalloc(sizeof(FILEEXT));
  117.     if(!af)
  118.         return NULL;
  119.     buf = zmalloc(BUFSIZE);
  120.     if(!buf)
  121.     {
  122.         free(af);
  123.         return NULL;
  124.     }
  125.     if(!strcmp(mode,"r"))
  126.     {
  127.         af->_flag = _IOREAD | _IOMYBUF;
  128.     }
  129.     else if(!strcmp(mode,"w"))
  130.     {
  131.         af->_flag = _IOWRT | _IOMYBUF;
  132.     }
  133.     else
  134.     {
  135.         fprintf(stderr,"s_fdopen: mode \"%s\" not supported\n", mode);
  136.  
  137.         free(af);
  138.         free(buf);
  139.         return 0;
  140.     }
  141.     
  142.     if(!files)
  143.         atexit(s_fcloseall);
  144.  
  145.     af->_next = files;
  146.     af->_ptr = buf;
  147.     af->_base = buf;
  148.     af->_size = BUFSIZE;
  149.     af->_flag |= _IOSOCK;
  150.     af->_file = fd;
  151.     files = af;
  152.  
  153.     return af;
  154.     }
  155. }
  156.  
  157. void s_fclose(FILE *af)
  158. {
  159.     FILE *pf = NULL, *sf = files;
  160.  
  161.     if(af->_file == 1)
  162.     {
  163.     fprintf(stderr,"s_fclose: someone tries to close stdout ;-(\n");
  164.     }
  165.  
  166.     if(!(af->_flag & _IOSOCK))
  167.     {
  168.     fclose(af);
  169.     }
  170.     else
  171.     {
  172.     if(af->_flag & _IOWRT)
  173.         s_fflush(af);
  174.  
  175.     while(sf && sf != af)
  176.     {
  177.         pf = sf;
  178.         sf = sf->_next;
  179.     }
  180.     if(sf)
  181.     {
  182.         if(pf)
  183.         pf->_next = sf->_next;
  184.         else
  185.         files = sf->_next;
  186. #if 1
  187.         if(! fd_has_refs(files, fileno(sf)))
  188.         s_close(fileno(sf)); /* FIXME: is this correct ? */
  189. #endif
  190.         free(sf->_base);
  191.         free(sf);
  192.     }
  193.     else
  194.     {
  195.         fprintf(stderr,"s_flose: illegal argument !!\n");
  196.     }
  197.     }
  198. }
  199.  
  200. size_t s_fread(void *b, size_t bsize, size_t n, FILE *fp)
  201. {
  202.     if(!(fp->_flag & _IOSOCK))
  203.     {
  204.     return fread(b, bsize, n, fp);
  205.     }
  206.     else
  207.     {
  208.     fprintf(stderr,"s_fread: not supported for sockets\n");
  209.     exit(20);
  210.     }
  211. }
  212. size_t s_fwrite(void *b, size_t bsize, size_t n, FILE *fp)
  213. {
  214.     if(!(fp->_flag & _IOSOCK))
  215.     {
  216.     return fwrite(b, bsize, n, fp);
  217.     }
  218.     else
  219.     {
  220.     fprintf(stderr,"s_ffwrite: not supported for sockets\n");
  221.     exit(20);
  222.     }
  223. }
  224.  
  225. static __inline int _s_fgetc(FILE *af)
  226. {
  227.     int n;
  228.  
  229.     if(af->_flag & _IOEOF)
  230.     {
  231.     return EOF;
  232.     }
  233.     if(--(af->_rcnt) >= 0)
  234.     {
  235.     return *(af->_ptr)++;
  236.     }
  237.     else
  238.     {
  239.     af->_ptr = af->_base;
  240.     n = s_recv(fileno(af), af->_base, af->_size, 0);
  241.     if(n > 0)
  242.     {
  243.         af->_rcnt = n-1;
  244.  
  245.         return *(af->_ptr)++;
  246.     }
  247.     else if(n == -1)
  248.     {
  249.         af->_flag |= _IOERR;
  250.         
  251.         return EOF;
  252.     }
  253.     else
  254.     {
  255.         af->_flag |= _IOEOF;
  256.  
  257.         return EOF;
  258.     }
  259.     }
  260. }
  261.  
  262. char *s_fgets(char *b, int bsize, FILE *af)
  263. {
  264.     char *p;
  265.     int c;
  266.  
  267.     if(!(af->_flag & _IOSOCK))
  268.     {
  269.     return fgets(b, bsize, af);
  270.     }
  271.     else
  272.     {
  273.     p = b;
  274.     if(!(af->_flag & _IOREAD))
  275.     {
  276.         fprintf(stderr,"s_fgets: illegal operation (read)\n");
  277.         errno = EBADF;
  278.         
  279.         return NULL;
  280.     }
  281.     while(bsize-- && ((c = _s_fgetc(af)) != EOF) && (c != '\n'))
  282.         *p++ = c; 
  283.     if(p==b)
  284.         return NULL;
  285.     if((c == EOF) && errno)
  286.         return NULL;
  287.     *p = '\0';
  288.     return b;
  289.     }
  290. }
  291.  
  292. int s_fputs(const char *b, FILE *fp)
  293. {
  294.     if(!(fp->_flag & _IOSOCK))
  295.     {
  296.     return fputs(b, fp);
  297.     }
  298.     else
  299.     {
  300.     fprintf(stderr,"s_fputs: not supported for sockets\n");
  301.     exit(20);
  302.     }
  303. }
  304.  
  305. int s_fseek(FILE *fp, long rpos, int mode)
  306. {
  307.     if(!(fp->_flag & _IOSOCK))
  308.     {
  309.     return fseek(fp, rpos, mode);
  310.     }
  311.     else
  312.     {
  313.     fprintf(stderr,"s_fseek: not supported for sockets\n");
  314.     exit(20);
  315.     }
  316. }
  317.  
  318.  
  319. int s_fgetc(FILE *af)
  320. {
  321.     if(!(af->_flag & _IOSOCK))
  322.     {
  323.     return fgetc(af);
  324.     }
  325.     else
  326.     {
  327.     if(!(af->_flag & _IOREAD))
  328.     {
  329.         fprintf(stderr,"s_fgetc: illegal operation (read)\n");
  330.         errno = EBADF;
  331.  
  332.         return EOF;
  333.     }
  334.     return _s_fgetc(af);
  335.     }
  336. }
  337.  
  338. int s_fflush(FILEEXT *af)
  339. {
  340.     int nbytes, RetVal;
  341.  
  342.     if(!(af->_flag & _IOSOCK))
  343.     {
  344.     return fflush(af);
  345.     }
  346.     else
  347.     {
  348.     if(!(af->_flag & _IOWRT))
  349.     {
  350.         fprintf(stderr,"s_fflush: illegal operation (not write)\n");
  351.         errno = EBADF;
  352.  
  353.         return EOF;
  354.     }
  355.     if(af->_wcnt)
  356.     {
  357.         nbytes = s_send(fileno(af), af->_base, af->_wcnt, 0);
  358.         if(nbytes != af->_wcnt)
  359.         {
  360.         af->_flag |= _IOERR;
  361.         RetVal = EOF;
  362.         }
  363.         else
  364.         RetVal = 0;
  365.  
  366.         af->_wcnt = 0;
  367.         af->_ptr = af->_base;
  368.     }
  369.     else
  370.         RetVal = 0;
  371.  
  372.     return RetVal;
  373.     }
  374. }
  375.  
  376. int s_vfprintf(FILE *af, const char *fmt, va_list args)
  377. {
  378.     int n;
  379.  
  380. /*     va_start(args, fmt);*/
  381.     
  382.     /* if buffer gets exceeded, we loose */
  383.  
  384.     if(!(af->_flag & _IOSOCK))
  385.     {
  386.     n = vfprintf(af, (char *) fmt, args);
  387.     }
  388.     else
  389.     {
  390.     s_fflush(af);
  391.     n = af->_wcnt = vsprintf(af->_ptr, fmt, args);
  392.     af->_ptr += n;
  393.     if(n > af->_size)
  394.     {
  395.         fprintf(stderr,"vfprintf: file buf exceeded\n");
  396.         exit(20);
  397.     }
  398.     }
  399.     va_end(args);
  400.  
  401.     return n;
  402. }
  403.  
  404. int s_fprintf(FILEEXT *af, const char *fmt, ...)
  405. {
  406.     int n;
  407.     va_list args;
  408.  
  409.     va_start(args, fmt);
  410.     
  411.     /* if buffer gets exceeded, we loose */
  412.  
  413.     if(!(af->_flag & _IOSOCK))
  414.     {
  415.     n = vfprintf(af, (char *) fmt, args);
  416.     }
  417.     else
  418.     {
  419.     s_fflush(af);
  420.     n = af->_wcnt = vsprintf(af->_ptr, fmt, (va_list) args);
  421.     af->_ptr += n;
  422.     if(n > af->_size)
  423.     {
  424.         fprintf(stderr,"fprintf: file buf exceeded\n");
  425.         exit(20);
  426.     }
  427.     }
  428.     va_end(args);
  429.  
  430.     return n;
  431. }
  432.  
  433. int s_fputc(int c, FILEEXT *af)
  434. {
  435.     int success;
  436.  
  437.     if(!(af->_flag & _IOSOCK))
  438.     {
  439.     return fputc(c, af);
  440.     }
  441.     else
  442.     {
  443.     if(!(af->_flag & _IOWRT))
  444.     {
  445.         fprintf(stderr,"s_fflush: illegal operation (write)\n");
  446.         errno = EBADF;
  447.  
  448.         return -1;
  449.     }
  450.     if(af->_wcnt > af->_size)
  451.     {
  452.         success = s_fflush(af);
  453.     }
  454.     (af->_wcnt)++;
  455.     *(af->_ptr)++ = c;
  456.  
  457.     return success ? success : c;
  458.     }
  459. }
  460.  
  461. int s_ferror(FILE *af)
  462. {
  463.     if(!(af->_flag & _IOSOCK))
  464.     {
  465.     return ferror(af);
  466.     }
  467.     else
  468.     {
  469.     return 0;        /* FIXME */
  470.     }
  471. }
  472.  
  473. int s_read(int fh, void *buf, unsigned int len)
  474. {
  475.     if(fh < MAXFH)
  476.     return read(fh, buf, len);
  477.     else
  478.     return recv(fh-MAXFH, buf, len, 0);
  479. }
  480.  
  481. int s_write(int fh, void *buf, unsigned int len)
  482. {
  483.     if(fh < MAXFH)
  484.     return write(fh, buf, len);
  485.     else
  486.     return send(fh-MAXFH, buf, len, 0);
  487. }
  488.  
  489.  
  490. int s_close(int sd)
  491. {
  492.     int RetVal;
  493.  
  494.     if(sd == 1)
  495.     {
  496.     fprintf(stderr,"s_close: someone tries to close stdout ;-(\n");
  497.     }
  498.     if(sd < MAXFH)
  499.     return close(sd);
  500.     else
  501.     {
  502. #if 0
  503.     fprintf(stderr,"s_close(%d)\n", sd -S_MAXFH);
  504. #endif
  505.     RetVal = CloseSocket(sd - MAXFH);
  506. #if 0
  507.     if(RetVal)
  508.     {
  509.         perror("s_close failed\n");
  510.     }
  511. #endif
  512.     }
  513.     return RetVal;
  514. }
  515.  
  516. int s_isatty(int sd)
  517. {
  518.     if(sd < MAXFH)
  519.     return isatty(sd);
  520.     else
  521.     {
  522.     return 0;
  523.     }
  524. }
  525.  
  526. int s_iomode(int sd, int mode)
  527. {
  528.     if(sd < MAXFH)
  529.     return isatty(sd);
  530.     else
  531.     {
  532.     return 1; /* not a level 1 file FIXME: call for sockets available? */
  533.     }
  534. }
  535.  
  536. long s_lseek(int sd, long a, int mode)
  537. {
  538.     if(sd < MAXFH)
  539.     return lseek(sd, a, mode);
  540.     else
  541.     {
  542.     fprintf(stderr,"s_lseek: not supported for sockets\n");
  543.     exit(20);
  544.     }
  545. }
  546.  
  547. long s_accept(long s, struct sockaddr *addr, int *addrlen)
  548. {
  549.     int ns;
  550.  
  551.     ns = accept(s-S_MAXFH, addr, (long *) addrlen);
  552.     if(ns>=0)
  553.     ns += S_MAXFH;
  554.     return ns;
  555. }
  556.  
  557. long s_bind(long s, struct sockaddr *name, long namelen)
  558. {
  559.     return bind(s-S_MAXFH, name, namelen);
  560. }
  561.  
  562. long s_CloseSocket(long sd)
  563. {
  564.     return CloseSocket(sd-S_MAXFH);
  565. }
  566.  
  567. long s_connect(long s, struct sockaddr *name, long namelen)
  568. {
  569.     return connect(s-S_MAXFH, name, namelen);
  570. }
  571.  
  572. long s_getpeername(long s, struct sockaddr *name, int *namelen)
  573. {
  574.     return getpeername(s-S_MAXFH, name, (long *) namelen);
  575. }
  576.  
  577. long s_getsockname(long s, struct sockaddr *name, int *namelen)
  578. {
  579.     return getsockname(s-S_MAXFH, name, (long *) namelen);
  580. }
  581.  
  582. long s_setsockopt(long s, long level, long optname, caddr_t optval, long optlen)
  583. {
  584.     return setsockopt(s-S_MAXFH, level, optname, optval, optlen);
  585. } 
  586.  
  587. long s_listen(long s, long backlog)
  588. {
  589.     return listen(s-S_MAXFH, backlog);
  590. }
  591.  
  592. long s_recv(long s, char *buf, long len, long flags)
  593. {
  594.     int n;
  595.  
  596.     n = recv(s-S_MAXFH, buf, len, flags);
  597. #if 0
  598.     if(n != -1)
  599.     {
  600.     fprintf(stderr,"s_recv = ");
  601.     write(2, buf, n);
  602.     fprintf(stderr,"\n");
  603.     }
  604.     else
  605.     {
  606.     fprintf(stderr,"recv returned -1\n");
  607.     }
  608. #endif
  609.     return n;
  610. }
  611.  
  612. long s_recvfrom(long s, char *buf, long len, long flags, 
  613.         struct sockaddr *from, long *len2)
  614. {
  615.     int n;
  616.  
  617.     n = recvfrom(s-S_MAXFH, buf, len, flags, from, len2);
  618.     return n;
  619. }
  620.  
  621. long s_select(long nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
  622.           struct timeval *timeout)
  623. {
  624.     return select(nfds, readfds, writefds, exceptfds, timeout);
  625. }
  626.  
  627. int s_send(int s, char *msg, int len, int flags)
  628. {
  629.     return send(s-S_MAXFH, msg, len, flags);
  630. }
  631.  
  632. int s_sendto(int s, char *msg, int len, int flags,
  633.          struct sockaddr *to, long len2)
  634. {
  635.     return sendto(s-S_MAXFH, msg, len, flags, to, len2);
  636. }
  637.  
  638. long s_shutdown(long s, long how)
  639. {
  640.     return shutdown(s-S_MAXFH, how);
  641. }
  642.  
  643. long s_socket(long domain, long type, long protocol)
  644. {
  645.     int s;
  646.     
  647.     s = socket(domain, type, protocol);
  648.     if(s>=0)
  649.     s += S_MAXFH;
  650.  
  651.     return s;
  652. }
  653.